Nos proponemos hacer el siguiente programa: pedimos un valor real al usuario y luego mostramos por pantalla 1 si el valor está entre 0.0 y 1.0 y 0 si está fuera (mayor que 1 o menor que 0).
Empezaremos utilizando 2 expresiones para detectar si la variable, que llamaremos x, está por encima de 0 y por debajo de 1. El resultado lo queremos poner en la variable r (el "r"esultado).
int main() { double x; cin >> x; bool r; // aquí habrá el resultado bool menor_que_1 = x < 1.0; bool mayor_que_0 = x > 0.0; r = /* qué hay que poner aquí?? */; cout << r << endl; }
El problema radica en "combinar" las dos variables menor_que_1 y mayor_que_0 para que se cumplan a la vez. Si lo pensamos queremos un operador con resultado Booleano cuyos operandos sean también Booleanos, y que devuelva true cuando los dos operandos valgan true a la vez. O sea, un número x está dentro del intervalo 0.0-1.0 cuando se cumple a la vez que es menor que 1 y mayor que 0.
El operador que buscamos es la conjunción, o el AND lógico. En C++ se puede escribir de dos maneras: "&&" o "and". De todas maneras la versión "&&" es la más utilizada. Como que hay solo 4 posibles combinaciones de valores de los operandos se puede poner una tabla donde aparecen todos los resultados posibles:
menor_que_1 | mayor_que_0 | dentro del intervalo |
---|---|---|
false | false | false |
false | true | false |
true | false | false |
true | true | true |
Es importante ver que en este caso, solo podemos decir que x está en el intervalo cuando las dos variables menor_que_1 y mayor_que_0 sean ciertas. Si falla cualquiera de las 2 ya no estamos dentro del intervalo.
Solo nos falta entonces reescribir la instrucción que asigna r utilizando el operador AND. La instrucción será:
r = menor_que_1 && mayor_que_0;
Para simplificar, podemos reescribir la expresión sin utilizar las dos variables intermedias menor_que_1 y mayor_que_0. Quedaría así:
int main() { double x; cin >> x; bool dentro; dentro = x > 0.0 && x < 1.0; cout << dentro << endl; }
También hemos renombrado r a dentro que ilustra mejor el uso que se hace de esta variable. De hecho, cabría incluso quitar la variable dentro, porque la expresión se puede poner directamente en la instrucción final:
int main() { double x; cin >> x; cout << (x > 0.0 && x < 1.0) << endl; }
Los paréntesis delimitan la expresión y evitan que los operadores << de cout se apliquen antes que el AND.
Si tenemos las declaraciones
int a = 1, b = 3; char c = 'a', d = 'd'; double x = 0.0, y = 1.2; string s1 = "aab", s2 = "ccd";
evalúa las siguientes expresiones
a > 1 && b < 2 c == 'z' && d == 'd' c != 'a' && c != 'd' a == 1 && b == 3 s1 > "aaa" && s1 < "zzz" s1 != s2 && s1 + "b" == "aabb" a / b == 0 && a % b == 0
Si suponemos que tenemos una variable c de tipo char, qué problema tiene la expresión siguiente?
c != 'a' && 'b'
Qué crees que significa y cómo la arreglarías?
Evalúa las siguientes expresiones (con a y b de tipo int, y c de tipo char) para distintos valores de a, b y c e indica cuál es el problema que observas:
c == 'a' && c == 'b' a > 1 && a < -1 c != 'a' && c == 'a' a / b == 1 && b > a
En preparación